MAYBE 150.103 H-Termination proof of /home/matraf/haskell/eval_FullyBlown_Fast/List.hs
H-Termination of the given Haskell-Program with start terms could not be shown:



HASKELL
  ↳ LR

mainModule List
  ((group :: [Float ->  [[Float]]) :: [Float ->  [[Float]])

module List where
  import qualified Maybe
import qualified Prelude

  group :: Eq a => [a ->  [[a]]
group groupBy (==)

  groupBy :: (a  ->  a  ->  Bool ->  [a ->  [[a]]
groupBy [] []
groupBy eq (x : xs
(x : ys: groupBy eq zs where 
vv10 span (eq x) xs
ys (\(ys,_) ->ys) vv10
zs (\(_,zs) ->zs) vv10


module Maybe where
  import qualified List
import qualified Prelude



Lambda Reductions:
The following Lambda expression
\(_,zs)→zs

is transformed to
zs0 (_,zs) = zs

The following Lambda expression
\(ys,_)→ys

is transformed to
ys0 (ys,_) = ys

The following Lambda expression
\(_,zs)→zs

is transformed to
zs1 (_,zs) = zs

The following Lambda expression
\(ys,_)→ys

is transformed to
ys1 (ys,_) = ys



↳ HASKELL
  ↳ LR
HASKELL
      ↳ BR

mainModule List
  ((group :: [Float ->  [[Float]]) :: [Float ->  [[Float]])

module List where
  import qualified Maybe
import qualified Prelude

  group :: Eq a => [a ->  [[a]]
group groupBy (==)

  groupBy :: (a  ->  a  ->  Bool ->  [a ->  [[a]]
groupBy [] []
groupBy eq (x : xs
(x : ys: groupBy eq zs where 
vv10 span (eq x) xs
ys ys0 vv10
ys0 (ys,_) ys
zs zs0 vv10
zs0 (_,zszs


module Maybe where
  import qualified List
import qualified Prelude



Replaced joker patterns by fresh variables and removed binding patterns.
Binding Reductions:
The bind variable of the following binding Pattern
xs@(ww : wx)

is replaced by the following term
ww : wx



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
HASKELL
          ↳ COR

mainModule List
  ((group :: [Float ->  [[Float]]) :: [Float ->  [[Float]])

module List where
  import qualified Maybe
import qualified Prelude

  group :: Eq a => [a ->  [[a]]
group groupBy (==)

  groupBy :: (a  ->  a  ->  Bool ->  [a ->  [[a]]
groupBy vw [] []
groupBy eq (x : xs
(x : ys: groupBy eq zs where 
vv10 span (eq x) xs
ys ys0 vv10
ys0 (ys,vxys
zs zs0 vv10
zs0 (vy,zszs


module Maybe where
  import qualified List
import qualified Prelude



Cond Reductions:
The following Function with conditions
undefined 
 | False
 = undefined

is transformed to
undefined  = undefined1

undefined0 True = undefined

undefined1  = undefined0 False

The following Function with conditions
span p [] = ([],[])
span p (ww : wx)
 | p ww
 = (ww : ys,zs)
 | otherwise
 = ([],ww : wx)
where 
vu43  = span p wx
ys  = ys1 vu43
ys1 (ys,wz) = ys
zs  = zs1 vu43
zs1 (wy,zs) = zs

is transformed to
span p [] = span3 p []
span p (ww : wx) = span2 p (ww : wx)

span2 p (ww : wx) = 
span1 p ww wx (p ww)
where 
span0 p ww wx True = ([],ww : wx)
span1 p ww wx True = (ww : ys,zs)
span1 p ww wx False = span0 p ww wx otherwise
vu43  = span p wx
ys  = ys1 vu43
ys1 (ys,wz) = ys
zs  = zs1 vu43
zs1 (wy,zs) = zs

span3 p [] = ([],[])
span3 xx xy = span2 xx xy



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
HASKELL
              ↳ LetRed

mainModule List
  ((group :: [Float ->  [[Float]]) :: [Float ->  [[Float]])

module List where
  import qualified Maybe
import qualified Prelude

  group :: Eq a => [a ->  [[a]]
group groupBy (==)

  groupBy :: (a  ->  a  ->  Bool ->  [a ->  [[a]]
groupBy vw [] []
groupBy eq (x : xs
(x : ys: groupBy eq zs where 
vv10 span (eq x) xs
ys ys0 vv10
ys0 (ys,vxys
zs zs0 vv10
zs0 (vy,zszs


module Maybe where
  import qualified List
import qualified Prelude



Let/Where Reductions:
The bindings of the following Let/Where expression
(x : ys: groupBy eq zs
where 
vv10  = span (eq xxs
ys  = ys0 vv10
ys0 (ys,vx) = ys
zs  = zs0 vv10
zs0 (vy,zs) = zs

are unpacked to the following functions on top level
groupByYs xz yu yv = groupByYs0 xz yu yv (groupByVv10 xz yu yv)

groupByVv10 xz yu yv = span (xz yuyv

groupByZs xz yu yv = groupByZs0 xz yu yv (groupByVv10 xz yu yv)

groupByZs0 xz yu yv (vy,zs) = zs

groupByYs0 xz yu yv (ys,vx) = ys

The bindings of the following Let/Where expression
span1 p ww wx (p ww)
where 
span0 p ww wx True = ([],ww : wx)
span1 p ww wx True = (ww : ys,zs)
span1 p ww wx False = span0 p ww wx otherwise
vu43  = span p wx
ys  = ys1 vu43
ys1 (ys,wz) = ys
zs  = zs1 vu43
zs1 (wy,zs) = zs

are unpacked to the following functions on top level
span2Vu43 yw yx = span yw yx

span2Span1 yw yx p ww wx True = (ww : span2Ys yw yx,span2Zs yw yx)
span2Span1 yw yx p ww wx False = span2Span0 yw yx p ww wx otherwise

span2Ys1 yw yx (ys,wz) = ys

span2Zs yw yx = span2Zs1 yw yx (span2Vu43 yw yx)

span2Ys yw yx = span2Ys1 yw yx (span2Vu43 yw yx)

span2Span0 yw yx p ww wx True = ([],ww : wx)

span2Zs1 yw yx (wy,zs) = zs



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
HASKELL
                  ↳ Narrow
                  ↳ Narrow

mainModule List
  (group :: [Float ->  [[Float]])

module List where
  import qualified Maybe
import qualified Prelude

  group :: Eq a => [a ->  [[a]]
group groupBy (==)

  groupBy :: (a  ->  a  ->  Bool ->  [a ->  [[a]]
groupBy vw [] []
groupBy eq (x : xs(x : groupByYs eq x xs: groupBy eq (groupByZs eq x xs)

  
groupByVv10 xz yu yv span (xz yu) yv

  
groupByYs xz yu yv groupByYs0 xz yu yv (groupByVv10 xz yu yv)

  
groupByYs0 xz yu yv (ys,vxys

  
groupByZs xz yu yv groupByZs0 xz yu yv (groupByVv10 xz yu yv)

  
groupByZs0 xz yu yv (vy,zszs


module Maybe where
  import qualified List
import qualified Prelude



Haskell To QDPs


↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs1(yy15, yy180, yy181) → new_span2Zs(yy15, yy181)
new_span2Zs(yy15, :(yy180, yy181)) → new_span2Zs1(yy15, yy180, yy181)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs10(yy15, yy1600, yy180, yy181) → new_span2Zs0(yy15, yy1600, yy181)
new_span2Zs0(yy15, yy1600, :(yy180, yy181)) → new_span2Zs10(yy15, yy1600, yy180, yy181)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs11(yy52, yy53, yy540, yy541) → new_span2Zs2(yy52, yy53, yy541)
new_span2Zs2(yy52, yy53, :(yy540, yy541)) → new_span2Zs11(yy52, yy53, yy540, yy541)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Ys(yy10, :(yy130, yy131)) → new_span2Ys1(yy10, yy130, yy131)
new_span2Ys1(yy10, yy130, yy131) → new_span2Ys(yy10, yy131)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_primPlusNat(Succ(yy10500), Succ(yy3100000)) → new_primPlusNat(yy10500, yy3100000)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_primMulNat(Succ(yy300000), yy310000) → new_primMulNat(yy300000, yy310000)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_primMulNat0(Succ(yy19000), Succ(yy37000)) → new_primMulNat0(yy19000, Succ(yy37000))

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_primEqNat(Succ(yy209900), Succ(yy210600)) → new_primEqNat(yy209900, yy210600)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ UsableRulesProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs3(:(yy3110, yy3111)) → new_span2Zs12(yy3110, yy3111, new_primEqFloat(Float(Pos(Zero), Pos(Zero)), yy3110))
new_span2Zs12(yy3110, yy3111, True) → new_span2Zs3(yy3111)

The TRS R consists of the following rules:

new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt4(Zero) → True
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqInt5(Zero) → True
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primEqInt4(Succ(yy21090)) → False
new_primEqInt3(yy20990, yy2107) → False
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt(Succ(yy21080)) → False
new_primPlusNat0(Zero, Zero) → Zero
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Zero) → True
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt2(yy20990, Zero) → False
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt(Zero) → True
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ UsableRulesProof
QDP
                            ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs3(:(yy3110, yy3111)) → new_span2Zs12(yy3110, yy3111, new_primEqFloat(Float(Pos(Zero), Pos(Zero)), yy3110))
new_span2Zs12(yy3110, yy3111, True) → new_span2Zs3(yy3111)

The TRS R consists of the following rules:

new_primEqFloat(Float(Pos(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primEqInt2(yy20990, Zero) → False
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt(Succ(yy21080)) → False
new_primEqInt(Zero) → True
new_primEqInt3(yy20990, yy2107) → False
new_primEqInt4(Zero) → True
new_primEqInt4(Succ(yy21090)) → False
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Zero) → True
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt8(Zero) → True

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Ys0(yy21, :(yy220, yy221)) → new_span2Ys10(yy21, yy220, yy221, new_primEqFloat(yy21, yy220))
new_span2Ys10(yy21, yy220, yy221, True) → new_span2Ys0(yy21, yy221)

The TRS R consists of the following rules:

new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt4(Zero) → True
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqInt5(Zero) → True
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primEqInt4(Succ(yy21090)) → False
new_primEqInt3(yy20990, yy2107) → False
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt(Succ(yy21080)) → False
new_primPlusNat0(Zero, Zero) → Zero
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Zero) → True
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt2(yy20990, Zero) → False
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt(Zero) → True
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ UsableRulesProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs4(:(yy3110, yy3111)) → new_span2Zs13(yy3110, yy3111, new_primEqFloat(Float(Neg(Zero), Neg(Zero)), yy3110))
new_span2Zs13(yy3110, yy3111, True) → new_span2Zs4(yy3111)

The TRS R consists of the following rules:

new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt4(Zero) → True
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqInt5(Zero) → True
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primEqInt4(Succ(yy21090)) → False
new_primEqInt3(yy20990, yy2107) → False
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt(Succ(yy21080)) → False
new_primPlusNat0(Zero, Zero) → Zero
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Zero) → True
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt2(yy20990, Zero) → False
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt(Zero) → True
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ UsableRulesProof
QDP
                            ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs4(:(yy3110, yy3111)) → new_span2Zs13(yy3110, yy3111, new_primEqFloat(Float(Neg(Zero), Neg(Zero)), yy3110))
new_span2Zs13(yy3110, yy3111, True) → new_span2Zs4(yy3111)

The TRS R consists of the following rules:

new_primEqFloat(Float(Neg(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primEqInt2(yy20990, Zero) → False
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt(Succ(yy21080)) → False
new_primEqInt(Zero) → True
new_primEqInt3(yy20990, yy2107) → False
new_primEqInt4(Zero) → True
new_primEqInt4(Succ(yy21090)) → False
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Zero) → True
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt8(Zero) → True

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ UsableRulesProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs14(yy3110, yy3111, True) → new_span2Zs5(yy3111)
new_span2Zs5(:(yy3110, yy3111)) → new_span2Zs14(yy3110, yy3111, new_primEqFloat(Float(Neg(Zero), Pos(Zero)), yy3110))

The TRS R consists of the following rules:

new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt4(Zero) → True
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqInt5(Zero) → True
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primEqInt4(Succ(yy21090)) → False
new_primEqInt3(yy20990, yy2107) → False
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt(Succ(yy21080)) → False
new_primPlusNat0(Zero, Zero) → Zero
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Zero) → True
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt2(yy20990, Zero) → False
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt(Zero) → True
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ UsableRulesProof
QDP
                            ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs14(yy3110, yy3111, True) → new_span2Zs5(yy3111)
new_span2Zs5(:(yy3110, yy3111)) → new_span2Zs14(yy3110, yy3111, new_primEqFloat(Float(Neg(Zero), Pos(Zero)), yy3110))

The TRS R consists of the following rules:

new_primEqFloat(Float(Neg(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primEqInt2(yy20990, Zero) → False
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt(Succ(yy21080)) → False
new_primEqInt(Zero) → True
new_primEqInt3(yy20990, yy2107) → False
new_primEqInt4(Zero) → True
new_primEqInt4(Succ(yy21090)) → False
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Zero) → True
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt8(Zero) → True

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ UsableRulesProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs6(:(yy3110, yy3111)) → new_span2Zs15(yy3110, yy3111, new_primEqFloat(Float(Pos(Zero), Neg(Zero)), yy3110))
new_span2Zs15(yy3110, yy3111, True) → new_span2Zs6(yy3111)

The TRS R consists of the following rules:

new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt4(Zero) → True
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqInt5(Zero) → True
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primEqInt4(Succ(yy21090)) → False
new_primEqInt3(yy20990, yy2107) → False
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt(Succ(yy21080)) → False
new_primPlusNat0(Zero, Zero) → Zero
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Zero) → True
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt2(yy20990, Zero) → False
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt(Zero) → True
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ UsableRulesProof
QDP
                            ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs6(:(yy3110, yy3111)) → new_span2Zs15(yy3110, yy3111, new_primEqFloat(Float(Pos(Zero), Neg(Zero)), yy3110))
new_span2Zs15(yy3110, yy3111, True) → new_span2Zs6(yy3111)

The TRS R consists of the following rules:

new_primEqFloat(Float(Pos(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primEqInt2(yy20990, Zero) → False
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt(Succ(yy21080)) → False
new_primEqInt(Zero) → True
new_primEqInt3(yy20990, yy2107) → False
new_primEqInt4(Zero) → True
new_primEqInt4(Succ(yy21090)) → False
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Zero) → True
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt8(Zero) → True

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ UsableRulesProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs7(yy30100, :(yy3110, yy3111)) → new_span2Zs16(yy30100, yy3110, yy3111, new_primEqFloat(Float(Neg(Zero), Neg(Succ(yy30100))), yy3110))
new_span2Zs16(yy30100, yy3110, yy3111, True) → new_span2Zs7(yy30100, yy3111)

The TRS R consists of the following rules:

new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt4(Zero) → True
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqInt5(Zero) → True
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primEqInt4(Succ(yy21090)) → False
new_primEqInt3(yy20990, yy2107) → False
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt(Succ(yy21080)) → False
new_primPlusNat0(Zero, Zero) → Zero
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Zero) → True
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt2(yy20990, Zero) → False
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt(Zero) → True
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ UsableRulesProof
QDP
                            ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs7(yy30100, :(yy3110, yy3111)) → new_span2Zs16(yy30100, yy3110, yy3111, new_primEqFloat(Float(Neg(Zero), Neg(Succ(yy30100))), yy3110))
new_span2Zs16(yy30100, yy3110, yy3111, True) → new_span2Zs7(yy30100, yy3111)

The TRS R consists of the following rules:

new_primEqFloat(Float(Neg(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primEqInt2(yy20990, Zero) → False
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt(Succ(yy21080)) → False
new_primEqInt(Zero) → True
new_primEqInt3(yy20990, yy2107) → False
new_primEqInt4(Zero) → True
new_primEqInt4(Succ(yy21090)) → False
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Zero) → True
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt8(Zero) → True

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ UsableRulesProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs17(yy30100, yy3110, yy3111, True) → new_span2Zs8(yy30100, yy3111)
new_span2Zs8(yy30100, :(yy3110, yy3111)) → new_span2Zs17(yy30100, yy3110, yy3111, new_primEqFloat(Float(Neg(Zero), Pos(Succ(yy30100))), yy3110))

The TRS R consists of the following rules:

new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt4(Zero) → True
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqInt5(Zero) → True
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primEqInt4(Succ(yy21090)) → False
new_primEqInt3(yy20990, yy2107) → False
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt(Succ(yy21080)) → False
new_primPlusNat0(Zero, Zero) → Zero
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Zero) → True
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt2(yy20990, Zero) → False
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt(Zero) → True
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ UsableRulesProof
QDP
                            ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs17(yy30100, yy3110, yy3111, True) → new_span2Zs8(yy30100, yy3111)
new_span2Zs8(yy30100, :(yy3110, yy3111)) → new_span2Zs17(yy30100, yy3110, yy3111, new_primEqFloat(Float(Neg(Zero), Pos(Succ(yy30100))), yy3110))

The TRS R consists of the following rules:

new_primEqFloat(Float(Neg(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primEqInt2(yy20990, Zero) → False
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt(Succ(yy21080)) → False
new_primEqInt(Zero) → True
new_primEqInt3(yy20990, yy2107) → False
new_primEqInt4(Zero) → True
new_primEqInt4(Succ(yy21090)) → False
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Zero) → True
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt8(Zero) → True

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ UsableRulesProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs18(yy30000, yy3110, yy3111, True) → new_span2Zs9(yy30000, yy3111)
new_span2Zs9(yy30000, :(yy3110, yy3111)) → new_span2Zs18(yy30000, yy3110, yy3111, new_primEqFloat(Float(Neg(Succ(yy30000)), Neg(Zero)), yy3110))

The TRS R consists of the following rules:

new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt4(Zero) → True
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqInt5(Zero) → True
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primEqInt4(Succ(yy21090)) → False
new_primEqInt3(yy20990, yy2107) → False
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt(Succ(yy21080)) → False
new_primPlusNat0(Zero, Zero) → Zero
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Zero) → True
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt2(yy20990, Zero) → False
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt(Zero) → True
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ UsableRulesProof
QDP
                            ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs18(yy30000, yy3110, yy3111, True) → new_span2Zs9(yy30000, yy3111)
new_span2Zs9(yy30000, :(yy3110, yy3111)) → new_span2Zs18(yy30000, yy3110, yy3111, new_primEqFloat(Float(Neg(Succ(yy30000)), Neg(Zero)), yy3110))

The TRS R consists of the following rules:

new_primEqFloat(Float(Neg(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primEqInt2(yy20990, Zero) → False
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt(Succ(yy21080)) → False
new_primEqInt(Zero) → True
new_primEqInt3(yy20990, yy2107) → False
new_primEqInt4(Zero) → True
new_primEqInt4(Succ(yy21090)) → False
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Zero) → True
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt8(Zero) → True

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ UsableRulesProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs19(yy30000, yy30100, :(yy3110, yy3111)) → new_span2Zs110(yy30000, yy30100, yy3110, yy3111, new_primEqFloat(Float(Neg(Succ(yy30000)), Neg(Succ(yy30100))), yy3110))
new_span2Zs110(yy30000, yy30100, yy3110, yy3111, True) → new_span2Zs19(yy30000, yy30100, yy3111)

The TRS R consists of the following rules:

new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt4(Zero) → True
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqInt5(Zero) → True
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primEqInt4(Succ(yy21090)) → False
new_primEqInt3(yy20990, yy2107) → False
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt(Succ(yy21080)) → False
new_primPlusNat0(Zero, Zero) → Zero
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Zero) → True
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt2(yy20990, Zero) → False
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt(Zero) → True
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ UsableRulesProof
QDP
                            ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs19(yy30000, yy30100, :(yy3110, yy3111)) → new_span2Zs110(yy30000, yy30100, yy3110, yy3111, new_primEqFloat(Float(Neg(Succ(yy30000)), Neg(Succ(yy30100))), yy3110))
new_span2Zs110(yy30000, yy30100, yy3110, yy3111, True) → new_span2Zs19(yy30000, yy30100, yy3111)

The TRS R consists of the following rules:

new_primEqFloat(Float(Neg(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primEqInt2(yy20990, Zero) → False
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt(Succ(yy21080)) → False
new_primEqInt(Zero) → True
new_primEqInt3(yy20990, yy2107) → False
new_primEqInt4(Zero) → True
new_primEqInt4(Succ(yy21090)) → False
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Zero) → True
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt8(Zero) → True

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_groupByZs0(yy76, yy7700, yy78, yy7900, yy80, Succ(yy119400), Succ(yy123600)) → new_groupByZs0(yy76, yy7700, yy78, yy7900, yy80, yy119400, yy123600)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_groupByZs00(yy70, yy7100, yy72, yy7300, yy74, Succ(yy64400), Succ(yy65800)) → new_groupByZs00(yy70, yy7100, yy72, yy7300, yy74, yy64400, yy65800)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_groupByYs0(yy45, yy4600, yy47, yy4800, yy49, Succ(yy37300), Succ(yy40900)) → new_groupByYs0(yy45, yy4600, yy47, yy4800, yy49, yy37300, yy40900)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_groupByYs00(yy90, yy9100, yy92, yy9300, yy94, Succ(yy21100), Succ(yy24500)) → new_groupByYs00(yy90, yy9100, yy92, yy9300, yy94, yy21100, yy24500)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ UsableRulesProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs20(yy30000, yy30100, :(yy3110, yy3111)) → new_span2Zs111(yy30000, yy30100, yy3110, yy3111, new_primEqFloat(Float(Neg(Succ(yy30000)), Pos(Succ(yy30100))), yy3110))
new_span2Zs111(yy30000, yy30100, yy3110, yy3111, True) → new_span2Zs20(yy30000, yy30100, yy3111)

The TRS R consists of the following rules:

new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt4(Zero) → True
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqInt5(Zero) → True
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primEqInt4(Succ(yy21090)) → False
new_primEqInt3(yy20990, yy2107) → False
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt(Succ(yy21080)) → False
new_primPlusNat0(Zero, Zero) → Zero
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Zero) → True
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt2(yy20990, Zero) → False
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt(Zero) → True
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ UsableRulesProof
QDP
                            ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs20(yy30000, yy30100, :(yy3110, yy3111)) → new_span2Zs111(yy30000, yy30100, yy3110, yy3111, new_primEqFloat(Float(Neg(Succ(yy30000)), Pos(Succ(yy30100))), yy3110))
new_span2Zs111(yy30000, yy30100, yy3110, yy3111, True) → new_span2Zs20(yy30000, yy30100, yy3111)

The TRS R consists of the following rules:

new_primEqFloat(Float(Neg(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primEqInt2(yy20990, Zero) → False
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt(Succ(yy21080)) → False
new_primEqInt(Zero) → True
new_primEqInt3(yy20990, yy2107) → False
new_primEqInt4(Zero) → True
new_primEqInt4(Succ(yy21090)) → False
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Zero) → True
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt8(Zero) → True

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_groupByZs01(yy76, yy7700, yy78, yy7900, yy80, Succ(yy119400), Succ(yy123400)) → new_groupByZs01(yy76, yy7700, yy78, yy7900, yy80, yy119400, yy123400)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_groupByZs02(yy70, yy7100, yy72, yy7300, yy74, Succ(yy64400), Succ(yy65600)) → new_groupByZs02(yy70, yy7100, yy72, yy7300, yy74, yy64400, yy65600)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_groupByYs01(yy45, yy4600, yy47, yy4800, yy49, Succ(yy37300), Succ(yy40700)) → new_groupByYs01(yy45, yy4600, yy47, yy4800, yy49, yy37300, yy40700)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_groupByYs02(yy90, yy9100, yy92, yy9300, yy94, Succ(yy21100), Succ(yy24300)) → new_groupByYs02(yy90, yy9100, yy92, yy9300, yy94, yy21100, yy24300)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ UsableRulesProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs112(yy30100, yy3110, yy3111, True) → new_span2Zs21(yy30100, yy3111)
new_span2Zs21(yy30100, :(yy3110, yy3111)) → new_span2Zs112(yy30100, yy3110, yy3111, new_primEqFloat(Float(Pos(Zero), Neg(Succ(yy30100))), yy3110))

The TRS R consists of the following rules:

new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt4(Zero) → True
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqInt5(Zero) → True
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primEqInt4(Succ(yy21090)) → False
new_primEqInt3(yy20990, yy2107) → False
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt(Succ(yy21080)) → False
new_primPlusNat0(Zero, Zero) → Zero
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Zero) → True
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt2(yy20990, Zero) → False
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt(Zero) → True
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ UsableRulesProof
QDP
                            ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs112(yy30100, yy3110, yy3111, True) → new_span2Zs21(yy30100, yy3111)
new_span2Zs21(yy30100, :(yy3110, yy3111)) → new_span2Zs112(yy30100, yy3110, yy3111, new_primEqFloat(Float(Pos(Zero), Neg(Succ(yy30100))), yy3110))

The TRS R consists of the following rules:

new_primEqFloat(Float(Pos(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primEqInt2(yy20990, Zero) → False
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt(Succ(yy21080)) → False
new_primEqInt(Zero) → True
new_primEqInt3(yy20990, yy2107) → False
new_primEqInt4(Zero) → True
new_primEqInt4(Succ(yy21090)) → False
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Zero) → True
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt8(Zero) → True

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ UsableRulesProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs113(yy30100, yy3110, yy3111, True) → new_span2Zs22(yy30100, yy3111)
new_span2Zs22(yy30100, :(yy3110, yy3111)) → new_span2Zs113(yy30100, yy3110, yy3111, new_primEqFloat(Float(Pos(Zero), Pos(Succ(yy30100))), yy3110))

The TRS R consists of the following rules:

new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt4(Zero) → True
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqInt5(Zero) → True
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primEqInt4(Succ(yy21090)) → False
new_primEqInt3(yy20990, yy2107) → False
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt(Succ(yy21080)) → False
new_primPlusNat0(Zero, Zero) → Zero
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Zero) → True
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt2(yy20990, Zero) → False
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt(Zero) → True
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ UsableRulesProof
QDP
                            ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs113(yy30100, yy3110, yy3111, True) → new_span2Zs22(yy30100, yy3111)
new_span2Zs22(yy30100, :(yy3110, yy3111)) → new_span2Zs113(yy30100, yy3110, yy3111, new_primEqFloat(Float(Pos(Zero), Pos(Succ(yy30100))), yy3110))

The TRS R consists of the following rules:

new_primEqFloat(Float(Pos(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primEqInt2(yy20990, Zero) → False
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt(Succ(yy21080)) → False
new_primEqInt(Zero) → True
new_primEqInt3(yy20990, yy2107) → False
new_primEqInt4(Zero) → True
new_primEqInt4(Succ(yy21090)) → False
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Zero) → True
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt8(Zero) → True

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ UsableRulesProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs114(yy30000, yy3110, yy3111, True) → new_span2Zs23(yy30000, yy3111)
new_span2Zs23(yy30000, :(yy3110, yy3111)) → new_span2Zs114(yy30000, yy3110, yy3111, new_primEqFloat(Float(Pos(Succ(yy30000)), Neg(Zero)), yy3110))

The TRS R consists of the following rules:

new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt4(Zero) → True
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqInt5(Zero) → True
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primEqInt4(Succ(yy21090)) → False
new_primEqInt3(yy20990, yy2107) → False
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt(Succ(yy21080)) → False
new_primPlusNat0(Zero, Zero) → Zero
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Zero) → True
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt2(yy20990, Zero) → False
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt(Zero) → True
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ UsableRulesProof
QDP
                            ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs114(yy30000, yy3110, yy3111, True) → new_span2Zs23(yy30000, yy3111)
new_span2Zs23(yy30000, :(yy3110, yy3111)) → new_span2Zs114(yy30000, yy3110, yy3111, new_primEqFloat(Float(Pos(Succ(yy30000)), Neg(Zero)), yy3110))

The TRS R consists of the following rules:

new_primEqFloat(Float(Pos(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primEqInt2(yy20990, Zero) → False
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt(Succ(yy21080)) → False
new_primEqInt(Zero) → True
new_primEqInt3(yy20990, yy2107) → False
new_primEqInt4(Zero) → True
new_primEqInt4(Succ(yy21090)) → False
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Zero) → True
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt8(Zero) → True

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ UsableRulesProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs115(yy30000, yy3110, yy3111, True) → new_span2Zs24(yy30000, yy3111)
new_span2Zs24(yy30000, :(yy3110, yy3111)) → new_span2Zs115(yy30000, yy3110, yy3111, new_primEqFloat(Float(Pos(Succ(yy30000)), Pos(Zero)), yy3110))

The TRS R consists of the following rules:

new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt4(Zero) → True
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqInt5(Zero) → True
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primEqInt4(Succ(yy21090)) → False
new_primEqInt3(yy20990, yy2107) → False
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt(Succ(yy21080)) → False
new_primPlusNat0(Zero, Zero) → Zero
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Zero) → True
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt2(yy20990, Zero) → False
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt(Zero) → True
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ UsableRulesProof
QDP
                            ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs115(yy30000, yy3110, yy3111, True) → new_span2Zs24(yy30000, yy3111)
new_span2Zs24(yy30000, :(yy3110, yy3111)) → new_span2Zs115(yy30000, yy3110, yy3111, new_primEqFloat(Float(Pos(Succ(yy30000)), Pos(Zero)), yy3110))

The TRS R consists of the following rules:

new_primEqFloat(Float(Pos(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primEqInt2(yy20990, Zero) → False
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt(Succ(yy21080)) → False
new_primEqInt(Zero) → True
new_primEqInt3(yy20990, yy2107) → False
new_primEqInt4(Zero) → True
new_primEqInt4(Succ(yy21090)) → False
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Zero) → True
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt8(Zero) → True

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ UsableRulesProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs25(yy30000, yy30100, :(yy3110, yy3111)) → new_span2Zs116(yy30000, yy30100, yy3110, yy3111, new_primEqFloat(Float(Pos(Succ(yy30000)), Neg(Succ(yy30100))), yy3110))
new_span2Zs116(yy30000, yy30100, yy3110, yy3111, True) → new_span2Zs25(yy30000, yy30100, yy3111)

The TRS R consists of the following rules:

new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt4(Zero) → True
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqInt5(Zero) → True
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primEqInt4(Succ(yy21090)) → False
new_primEqInt3(yy20990, yy2107) → False
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt(Succ(yy21080)) → False
new_primPlusNat0(Zero, Zero) → Zero
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Zero) → True
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt2(yy20990, Zero) → False
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt(Zero) → True
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ UsableRulesProof
QDP
                            ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs25(yy30000, yy30100, :(yy3110, yy3111)) → new_span2Zs116(yy30000, yy30100, yy3110, yy3111, new_primEqFloat(Float(Pos(Succ(yy30000)), Neg(Succ(yy30100))), yy3110))
new_span2Zs116(yy30000, yy30100, yy3110, yy3111, True) → new_span2Zs25(yy30000, yy30100, yy3111)

The TRS R consists of the following rules:

new_primEqFloat(Float(Pos(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primEqInt2(yy20990, Zero) → False
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt(Succ(yy21080)) → False
new_primEqInt(Zero) → True
new_primEqInt3(yy20990, yy2107) → False
new_primEqInt4(Zero) → True
new_primEqInt4(Succ(yy21090)) → False
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Zero) → True
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt8(Zero) → True

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_groupByZs03(yy63, yy6400, yy65, yy6600, yy67, Succ(yy93800), Succ(yy98000)) → new_groupByZs03(yy63, yy6400, yy65, yy6600, yy67, yy93800, yy98000)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_groupByZs04(yy57, yy5800, yy59, yy6000, yy61, Succ(yy55100), Succ(yy56500)) → new_groupByZs04(yy57, yy5800, yy59, yy6000, yy61, yy55100, yy56500)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_groupByYs03(yy97, yy9800, yy99, yy10000, yy101, Succ(yy1200), Succ(yy137000)) → new_groupByYs03(yy97, yy9800, yy99, yy10000, yy101, yy1200, yy137000)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_groupByYs04(yy84, yy8500, yy86, yy8700, yy88, Succ(yy74300), Succ(yy76600)) → new_groupByYs04(yy84, yy8500, yy86, yy8700, yy88, yy74300, yy76600)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ UsableRulesProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs26(yy30000, yy30100, :(yy3110, yy3111)) → new_span2Zs117(yy30000, yy30100, yy3110, yy3111, new_primEqFloat(Float(Pos(Succ(yy30000)), Pos(Succ(yy30100))), yy3110))
new_span2Zs117(yy30000, yy30100, yy3110, yy3111, True) → new_span2Zs26(yy30000, yy30100, yy3111)

The TRS R consists of the following rules:

new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt4(Zero) → True
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqInt5(Zero) → True
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primEqInt4(Succ(yy21090)) → False
new_primEqInt3(yy20990, yy2107) → False
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt(Succ(yy21080)) → False
new_primPlusNat0(Zero, Zero) → Zero
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Zero) → True
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt2(yy20990, Zero) → False
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt(Zero) → True
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ UsableRulesProof
QDP
                            ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs26(yy30000, yy30100, :(yy3110, yy3111)) → new_span2Zs117(yy30000, yy30100, yy3110, yy3111, new_primEqFloat(Float(Pos(Succ(yy30000)), Pos(Succ(yy30100))), yy3110))
new_span2Zs117(yy30000, yy30100, yy3110, yy3111, True) → new_span2Zs26(yy30000, yy30100, yy3111)

The TRS R consists of the following rules:

new_primEqFloat(Float(Pos(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primEqInt2(yy20990, Zero) → False
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt(Succ(yy21080)) → False
new_primEqInt(Zero) → True
new_primEqInt3(yy20990, yy2107) → False
new_primEqInt4(Zero) → True
new_primEqInt4(Succ(yy21090)) → False
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Zero) → True
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt8(Zero) → True

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_groupByZs05(yy63, yy6400, yy65, yy6600, yy67, Succ(yy93800), Succ(yy97800)) → new_groupByZs05(yy63, yy6400, yy65, yy6600, yy67, yy93800, yy97800)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_groupByZs06(yy57, yy5800, yy59, yy6000, yy61, Succ(yy55100), Succ(yy56300)) → new_groupByZs06(yy57, yy5800, yy59, yy6000, yy61, yy55100, yy56300)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_groupByYs05(yy97, yy9800, yy99, yy10000, yy101, Succ(yy1190), Succ(yy135000)) → new_groupByYs05(yy97, yy9800, yy99, yy10000, yy101, yy1190, yy135000)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_groupByYs06(yy84, yy8500, yy86, yy8700, yy88, Succ(yy74300), Succ(yy76400)) → new_groupByYs06(yy84, yy8500, yy86, yy8700, yy88, yy74300, yy76400)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ NonTerminationProof
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_groupBynew_groupBy

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We used the non-termination processor [17] to show that the DP problem is infinite.
Found a loop by semiunifying a rule from P directly.

The TRS P consists of the following rules:

new_groupBynew_groupBy

The TRS R consists of the following rules:none


s = new_groupBy evaluates to t =new_groupBy

Thus s starts an infinite chain as s semiunifies with t with the following substitutions:




Rewriting sequence

The DP semiunifies directly so there is only one rewrite step from new_groupBy to new_groupBy.




Haskell To QDPs


↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                  ↳ Narrow
                    ↳ AND
QDP
                        ↳ PisEmptyProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP

Q DP problem:
P is empty.
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
QDP
                        ↳ PisEmptyProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP

Q DP problem:
P is empty.
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ PisEmptyProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP

Q DP problem:
P is empty.
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ PisEmptyProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP

Q DP problem:
P is empty.
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ PisEmptyProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP

Q DP problem:
P is empty.
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ PisEmptyProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP

Q DP problem:
P is empty.
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ PisEmptyProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP

Q DP problem:
P is empty.
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ PisEmptyProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP

Q DP problem:
P is empty.
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ PisEmptyProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP

Q DP problem:
P is empty.
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ PisEmptyProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP

Q DP problem:
P is empty.
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ PisEmptyProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP

Q DP problem:
P is empty.
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ PisEmptyProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP

Q DP problem:
P is empty.
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ PisEmptyProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP

Q DP problem:
P is empty.
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ PisEmptyProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP

Q DP problem:
P is empty.
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ PisEmptyProof
                      ↳ QDP
                      ↳ QDP

Q DP problem:
P is empty.
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ PisEmptyProof
                      ↳ QDP

Q DP problem:
P is empty.
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ PisEmptyProof

Q DP problem:
P is empty.
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.